Mark Seemann argues that fully LLM-driven software engineering could work—producing code as reliable as human-written systems—but legal systems will struggle to assign blame when things go wrong, likely scapegoating whoever signed off on the release rather than the AI that created the defect.

• Code review and human inspection were never foolproof either; the real question isn't whether LLM code is perfect, but whether it's better than human-driven processes, which it plausibly could be.
• Even if LLM-driven systems produce fewer bugs than human teams, courts and liability frameworks aren't equipped to handle a world where no individual "wrote" the problematic code—judges will still need someone to prosecute.
• People will adopt AI-driven systems aggressively (like Tesla FSD drivers ignoring the road) because the odds look good, then face severe legal consequences when rare failures occur, regardless of how robust their quality assurance actually was.

Jake Goldsborough argues that AI coding agents aren't killing software engineering—they're freeing engineers from tedious mechanical work so they can focus on the actual problem-solving that defines the craft. The hard parts that never mattered (regex wrestling, syntax memorization, build system incantations) are disappearing, but the work that requires real judgment and responsibility remains.

• The difficult parts of coding—parsing edge cases, remembering obscure syntax, navigating unfamiliar codebases—were never the point; they were tolls between understanding a problem and solving it, and removing them doesn't diminish engineering skill.
• Agents handle syntax and scaffolding faster, which lets engineers explore domains that were previously too expensive (rewriting programs in different languages, understanding unfamiliar systems, testing experimental ideas), actually tightening the learning loop rather than replacing it.
• The real shift is architectural: engineering moves from "produce every character by hand" to "direction, judgment, verification, and responsibility," and the actual risk isn't that the work disappears but that companies cut people, generated code creates failures at scale, and the junior-to-senior training path collapses.